package com.xiangxue.xc

import android.app.ProgressDialog
import android.os.Bundle
import android.util.Log
import android.view.View
import androidx.appcompat.app.AppCompatActivity
import kotlinx.android.synthetic.main.activity_main.*
import kotlinx.coroutines.*

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }

    fun click1(view: View) = runBlocking { // 外协程
        // runBlocking就是协程环境了  默认是：main线程
        launch(Dispatchers.IO) { // 内协程 未指定IO线程就是Main线程  Thread.currentThread().name就是main
            Log.e("click1: ", "launch ${Thread.currentThread().name}")

            repeat(10) {
                Thread.sleep(1000)
                Log.e("click1: ", "计数中: ${it}")
            }
        }
    }

    fun click2(view: View) = runBlocking {
        // 不适用协程
        // displayMethod(textView)

        // 使用协程
        displayMethodOk(textView)
    }

    //runBlocking这是阻塞是阻塞式的   runBlocking先执行协程体里面的再执行外面的  runBlocking启动的协程任务会阻断当前线程，直到该协程执行结束。当协程执行结束之后，页面才会被显示出来。
    fun click3(view: View) = runBlocking {
        // TODO 完成这种  异步线程  和  主线程  的切换，  这个需求：之前我们用RxJava实现过了哦
        // 1.注册耗时操作
        // 2.注册耗时操作完成后，更新注册UI
        // 3.登录耗时操作
        // 4.登录耗时操作完成后，更新登录UI
        var pro = ProgressDialog(this@MainActivity)
        // main
        launch {
            pro.setMessage("正在执行中...")
            pro.show()

            Log.d("click3", "0: ${Thread.currentThread().name}")
            withContext(Dispatchers.IO) {
                // 1.注册耗时操作  异步
                Log.d("click3", "1.注册耗时操作: ${Thread.currentThread().name}")
                Thread.sleep(2000)
            }

            // 2.注册耗时操作完成后，更新注册UI  main
            Log.d("click3", "2.注册耗时操作完成后，更新注册UI: ${Thread.currentThread().name}")

            withContext(Dispatchers.IO) {
                // 3.登录耗时操作  异步
                Log.d("click3", "3.登录耗时操作: ${Thread.currentThread().name}")
                Thread.sleep(3000)
            }
            // 4.登录耗时操作完成后，更新登录UI
            Log.d("click3", "4.登录耗时操作完成后，更新登录UI: ${Thread.currentThread().name}")
            // pro.dismiss()
        }

    }

    /**
     * async和launch的区别

    launch 更多是用来发起一个无需结果的耗时任务，这个工作不需要返回结果。
    async 函数则是更进一步，用于异步执行耗时任务，并且需要返回值（如网络请求、数据库读写、文件读写），在执行完毕通过 await() 函数获取返回值。
     */
    // 非阻塞 GlobalScope   多个WithContext执行是串行的  相当于async /await组合   直接async就是并行执行的 获取结果的时候才await
    fun click4(view: View) {
        // TODO 完成这种  异步线程  和  主线程  的切换，  这个需求：之前我们用RxJava实现过了哦
        // 1.注册耗时操作
        // 2.注册耗时操作完成后，更新注册UI
        // 3.登录耗时操作
        // 4.登录耗时操作完成后，更新登录UI

        // main
        GlobalScope.launch(Dispatchers.Main) {

            val pro = ProgressDialog(this@MainActivity)
            pro.setMessage("正在执行中...")
            pro.show()

            withContext(Dispatchers.IO) {
                // 1.注册耗时操作  异步
                Log.d("click4", "1.注册耗时操作: ${Thread.currentThread().name}")
                Thread.sleep(2000)
            }

            // 2.注册耗时操作完成后，更新注册UI  main
            Log.d("click4", "2.注册耗时操作完成后，更新注册UI: ${Thread.currentThread().name}")
            textView.text = "注册成功，你可以去登录了"
            pro.setMessage(textView.text.toString())

            withContext(Dispatchers.IO) {
                // 3.登录耗时操作  异步
                Log.d("click4", "3.登录耗时操作: ${Thread.currentThread().name}")
                Thread.sleep(3000)
            }

            // 4.登录耗时操作完成后，更新登录UI
            Log.d("click4", "4.登录耗时操作完成后，更新登录UI: ${Thread.currentThread().name}")
            textView.text = "登录成功，欢迎回来"
            pro.setMessage(textView.text.toString())
            withContext(Dispatchers.IO) {
                Thread.sleep(1000)
            }
            pro.dismiss()
        }

    }


    fun click5(view: View) {
        val pro = ProgressDialog(this@MainActivity)
        pro.setMessage("正在执行中...")
        pro.show()
        // main
        GlobalScope.launch(Dispatchers.Main) {
            async {
                // 1.注册耗时操作  异步
                Log.d("click5", "1.注册耗时操作: ${Thread.currentThread().name}")
                Thread.sleep(2000)
            }.await()

            // 2.注册耗时操作完成后，更新注册UI  main
            Log.d("click5", "2.注册耗时操作完成后，更新注册UI: ${Thread.currentThread().name}")
            textView.text = "注册成功，你可以去登录了"
            pro.setMessage(textView.text.toString())

            async {
                // 3.登录耗时操作  异步
                Log.d("click5", "3.登录耗时操作: ${Thread.currentThread().name}")
                Thread.sleep(3000)
            }.await()

            // 4.登录耗时操作完成后，更新登录UI
            Log.d("click5", "4.登录耗时操作完成后，更新登录UI: ${Thread.currentThread().name}")
            textView.text = "登录成功，欢迎回来"
            pro.setMessage(textView.text.toString())
            async {
                Thread.sleep(1000)
            }.await()
            pro.dismiss()
        }

    }


    fun click6(view: View) {
        GlobalScope.launch {
            val async = async {
                delay(300)
                println(3)
                3
            }
            val async1 = async {
                delay(200)
                println(2)
                2
            }
            //println("1  "+async.await()+"  "+async1.await())// 2 3  123
            println("1")// 1 2 3
        }
    }


    fun click7(view: View) {
        GlobalScope.launch(Dispatchers.Main) {
            val pro = ProgressDialog(this@MainActivity)
            pro.setMessage("正在执行中...")
            pro.show()
            async {
                println(2)
            }.await()
            println(3)
        }
    }

    fun click8(view: View) {
        GlobalScope.launch(Dispatchers.Main) {
            val pro = ProgressDialog(this@MainActivity)
            pro.setMessage("正在执行中...")
            pro.show()
            withContext(Dispatchers.IO) {
                println(2)
            }
            println(3)
        }
    }
}
